// membership.js
Page({
  data: {
    membershipInfo: {
      levelName: '普通用户',
      isVip: false,
      benefits: [],
      expireTime: ''
    },
    // VIP套餐数据
    vipPlans: [],
    plansLoading: false,
    // VIP订单数据
    vipOrders: [],
    ordersLoading: false,
    loading: false,
    userInfo: {
      isLogin: false
    }
  },

  onLoad() {
    this.loadUserInfo()
    this.loadMembershipInfo()
    this.loadVipPlans()
  },

  onShow() {
    this.loadMembershipInfo()
    this.loadVipPlans()
  },

  // 加载用户信息
  loadUserInfo() {
    const app = getApp()
    const userInfo = app.getUserInfo()
    this.setData({ userInfo })
  },

  // 加载会员信息
  loadMembershipInfo() {
    if (!this.data.userInfo.isLogin) {
      this.setData({
        membershipInfo: {
          level: 'bronze',
          levelName: '青铜会员',
          points: 0,
          nextLevelPoints: 1000,
          benefits: [],
          expireTime: ''
        }
      })
      return
    }

    this.setData({ loading: true })
    this.getMembershipInfoFromAPI()
    this.loadVipOrders()
  },

  // 加载VIP套餐数据
  loadVipPlans() {
    this.setData({ plansLoading: true })
    
    wx.request({
      url: 'http://localhost:8081/viporder/viptaocanAll',
      method: 'GET',
      success: (res) => {
        this.setData({ plansLoading: false })
        
        if (res.data && Array.isArray(res.data)) {
          // 处理套餐数据，添加推荐标识
          const processedPlans = res.data.map((plan, index) => ({
            ...plan,
            isRecommended: index === 1, // 第二个套餐标记为推荐
            originalPrice: plan.price * 1.2, // 添加原价显示
            discount: Math.round((1 - plan.price / (plan.price * 1.2)) * 100) // 计算折扣
          }))
          
          this.setData({
            vipPlans: processedPlans
          })
        } else {
          console.error('VIP套餐数据格式错误:', res.data)
          this.setData({
            vipPlans: []
          })
        }
      },
      fail: (err) => {
        console.error('获取VIP套餐失败:', err)
        this.setData({ 
          plansLoading: false,
          vipPlans: []
        })
        
        // 显示错误提示
        wx.showToast({
          title: '获取套餐信息失败',
          icon: 'none'
        })
      }
    })
  },

  // 从API获取会员信息
  getMembershipInfoFromAPI() {
    wx.request({
      url: 'http://localhost:8082/user/membership',
      method: 'GET',
      header: {
        'Authorization': 'Bearer ' + wx.getStorageSync('token')
      },
      success: (res) => {
        this.setData({ loading: false })
        
        if (res.data && res.data.code === 200) {
          const data = res.data.data
          
          this.setData({
            membershipInfo: {
              levelName: data.isVip ? 'VIP会员' : '普通用户',
              isVip: data.isVip || false,
              benefits: data.benefits || ['基础课程学习', '社区交流', '每日签到奖励'],
              expireTime: data.expireTime || ''
            }
          })
        } else {
          // 默认普通用户
          this.setData({
            membershipInfo: {
              levelName: '普通用户',
              isVip: false,
              benefits: ['基础课程学习', '社区交流', '每日签到奖励'],
              expireTime: ''
            }
          })
        }
      },
      fail: (err) => {
        console.error('获取会员信息失败:', err)
        this.setData({ loading: false })
        // 默认普通用户
        this.setData({
          membershipInfo: {
            levelName: '普通用户',
            isVip: false,
            benefits: ['基础课程学习', '社区交流', '每日签到奖励'],
            expireTime: ''
          }
        })
      }
    })
  },

  // 加载VIP订单
  loadVipOrders() {
    if (!this.data.userInfo.isLogin) {
      return
    }

    this.setData({ ordersLoading: true })
    
    // 获取用户ID
    const globalUserInfo = getApp().getUserInfo()
    const userId = globalUserInfo ? globalUserInfo.id : null
    
    if (!userId) {
      console.error('用户ID不存在')
      this.setData({ 
        ordersLoading: false,
        vipOrders: []
      })
      return
    }

    wx.request({
      url: `http://localhost:8081/viporder/viptaocanById?userid=${userId}`,
      method: 'GET',
      success: (res) => {
        this.setData({ ordersLoading: false })
        
        console.log('订单列表API响应:', res.data)
        
        // 检查多种数据格式
        let ordersData = null
        if (Array.isArray(res.data)) {
          ordersData = res.data
        } else if (res.data && Array.isArray(res.data.data)) {
          ordersData = res.data.data
        } else if (res.data && res.data.list && Array.isArray(res.data.list)) {
          ordersData = res.data.list
        }
        
        if (ordersData) {
          this.setData({
            vipOrders: ordersData
          })
        } else {
          console.error('VIP订单数据格式错误:', res.data)
          this.setData({
            vipOrders: []
          })
        }
      },
      fail: (err) => {
        console.error('获取VIP订单失败:', err)
        this.setData({ 
          ordersLoading: false,
          vipOrders: []
        })
        
        wx.showToast({
          title: '获取订单信息失败',
          icon: 'none'
        })
      }
    })
  },

  // 支付订单
  onPayOrder(e) {
    const orderId = e.currentTarget.dataset.orderId
    const order = this.data.vipOrders.find(item => item.id == orderId)
    
    if (!order) {
      wx.showToast({
        title: '订单不存在',
        icon: 'none'
      })
      return
    }

    wx.showModal({
      title: '确认支付',
      content: `确认支付 ${order.viptaocan.vipname} ¥${order.viptaocan.price}？`,
      success: (res) => {
        if (res.confirm) {
          this.processPayment(orderId)
        }
      }
    })
  },

  // 处理支付
  processPayment(orderId) {
    wx.showLoading({ title: '准备支付...' })
    
    // 获取用户ID
    const globalUserInfo = getApp().getUserInfo()
    const userId = globalUserInfo ? globalUserInfo.id : null
    
    if (!userId) {
      wx.hideLoading()
      wx.showToast({
        title: '用户信息错误',
        icon: 'none'
      })
      return
    }

    // 获取订单信息
    const order = this.data.vipOrders.find(o => o.id == orderId)
    if (!order) {
      wx.hideLoading()
      wx.showToast({
        title: '订单不存在',
        icon: 'none'
      })
      return
    }

    // 调用支付宝二维码生成API
    wx.request({
      url: 'http://localhost:8081/api/alipay/generateQRCode',
      method: 'POST',
      header: {
        'Content-Type': 'application/json',
        'token': wx.getStorageSync('token')
      },
      data: {
        id: orderId,
        userid: userId,
        viptcid: order.viptcid,
        status: order.status
      },
      success: (res) => {
        wx.hideLoading()
        
        console.log('支付宝二维码响应:', res.data)
        console.log('响应状态码:', res.statusCode)
        
        if (res.data && res.data.code === 200) {
          // 存储支付数据
          wx.setStorageSync('paymentData', {
            orderNo: res.data.orderNo,
            amount: res.data.amount,
            subject: res.data.subject,
            paymentUrl: res.data.paymentUrl
          });
          wx.setStorageSync('currentOrderId', orderId);
          
          // 跳转到二维码支付页面
          wx.navigateTo({
            url: '/pages/payment-qr/payment-qr'
          });
        } else {
          console.error('二维码生成失败:', res.data)
          wx.showToast({
            title: res.data?.message || res.data || '二维码生成失败',
            icon: 'none',
            duration: 3000
          })
        }
      },
      fail: (err) => {
        wx.hideLoading()
        console.error('二维码生成失败:', err)
        console.error('错误详情:', JSON.stringify(err))
        
        // 显示详细的错误信息
        let errorMsg = '网络错误，请重试'
        if (err.statusCode === 404) {
          errorMsg = 'API接口不存在，请检查后端服务'
        } else if (err.statusCode === 500) {
          errorMsg = '服务器内部错误'
        } else if (err.statusCode === 0) {
          errorMsg = '网络连接失败，请检查网络'
        }
        
        wx.showToast({
          title: errorMsg,
          icon: 'none',
          duration: 3000
        })
      }
    })
  },

  // 测试API连接
  testAPIConnection() {
    wx.showLoading({ title: '测试API连接...' })
    
    wx.request({
      url: 'http://localhost:8081/api/alipay/test',
      method: 'GET',
      success: (res) => {
        wx.hideLoading()
        console.log('API测试响应:', res.data)
        wx.showToast({
          title: 'API连接正常',
          icon: 'success'
        })
      },
      fail: (err) => {
        wx.hideLoading()
        console.error('API测试失败:', err)
        wx.showToast({
          title: 'API连接失败',
          icon: 'none'
        })
      }
    })
  },

  // 显示二维码支付页面
  showQRCodePayment(paymentData, orderId) {
    // 将支付数据存储到本地
    wx.setStorageSync('paymentData', paymentData)
    wx.setStorageSync('currentOrderId', orderId)
    
    // 跳转到二维码支付页面
    wx.navigateTo({
      url: '/pages/payment/payment?orderId=' + orderId,
      success: () => {
        console.log('跳转到二维码支付页面成功')
      },
      fail: (err) => {
        console.error('跳转支付页面失败:', err)
        wx.showToast({
          title: '跳转支付页面失败',
          icon: 'none'
        })
      }
    })
  },

  // 显示HTML支付页面
  showHTMLPayment(htmlContent, orderId) {
    // 将HTML内容存储到本地
    wx.setStorageSync('paymentHtml', htmlContent)
    wx.setStorageSync('currentOrderId', orderId)
    
    // 跳转到web-view支付页面
    wx.navigateTo({
      url: '/pages/payment-webview/payment-webview?orderId=' + orderId,
      success: () => {
        console.log('跳转到HTML支付页面成功')
      },
      fail: (err) => {
        console.error('跳转支付页面失败:', err)
        wx.showToast({
          title: '跳转支付页面失败',
          icon: 'none'
        })
      }
    })
  },

  // 取消订单
  onCancelOrder(e) {
    const orderId = e.currentTarget.dataset.orderId
    const order = this.data.vipOrders.find(item => item.id == orderId)
    
    if (!order) {
      wx.showToast({
        title: '订单不存在',
        icon: 'none'
      })
      return
    }

    // 检查订单状态
    if (order.status === 1) {
      wx.showToast({
        title: '已支付订单无法取消',
        icon: 'none'
      })
      return
    }

    wx.showModal({
      title: '确认取消订单',
      content: `确定要取消订单吗？\n\n订单信息：\n${order.viptaocan.vipname}\n价格：¥${order.viptaocan.price}\n\n取消后无法恢复，请谨慎操作。`,
      confirmText: '确认取消',
      cancelText: '我再想想',
      success: (res) => {
        if (res.confirm) {
          this.processCancelOrder(orderId)
        }
      }
    })
  },

  // 处理取消订单
  processCancelOrder(orderId) {
    wx.showLoading({ title: '取消中...' })
    
    // 获取用户ID
    const globalUserInfo = getApp().getUserInfo()
    const userId = globalUserInfo ? globalUserInfo.id : null
    
    if (!userId) {
      wx.hideLoading()
      wx.showToast({
        title: '用户信息错误',
        icon: 'none'
      })
      return
    }

    // 先检查订单状态，只有未支付的订单才能取消
    const order = this.data.vipOrders.find(item => item.id == orderId)
    if (!order) {
      wx.hideLoading()
      wx.showToast({
        title: '订单不存在',
        icon: 'none'
      })
      return
    }

    if (order.status === 1) {
      wx.hideLoading()
      wx.showToast({
        title: '已支付订单无法取消',
        icon: 'none'
      })
      return
    }

    // 调用取消订单API
    wx.request({
      url: `http://localhost:8081/viporder/delOrder?id=${orderId}`,
      method: 'GET',
      success: (res) => {
        wx.hideLoading()
        
        console.log('取消订单API响应:', res.data)
        console.log('响应状态码:', res.statusCode)
        
        // 检查成功条件 - 后端返回成功消息
        const isSuccess = res.statusCode === 200 && 
                         (res.data === "取消订单成功" || 
                          (typeof res.data === 'string' && res.data.includes('成功')))
        
        // 检查失败条件
        const isError = typeof res.data === 'string' && 
                       (res.data.includes('失败') || 
                        res.data.includes('错误') || 
                        res.data.includes('不存在') || 
                        res.data.includes('无法取消'))
        
        if (isSuccess) {
          // 从订单列表中移除
          const updatedOrders = this.data.vipOrders.filter(order => order.id != orderId)
          
          this.setData({
            vipOrders: updatedOrders
          })
          
          wx.showToast({
            title: '订单已取消',
            icon: 'success'
          })
          
          // 显示取消成功提示
          setTimeout(() => {
            wx.showModal({
              title: '取消成功',
              content: '订单已成功取消，如有疑问请联系客服',
              showCancel: false,
              confirmText: '知道了'
            })
          }, 1000)
        } else if (isError) {
          // 显示具体的错误信息
          wx.showToast({
            title: res.data || '取消失败',
            icon: 'none',
            duration: 3000
          })
        } else {
          console.log('取消订单API失败，使用模拟取消')
          // API失败时使用模拟取消
          this.simulateCancelOrder(orderId)
        }
      },
      fail: (err) => {
        wx.hideLoading()
        console.error('取消订单API调用失败:', err)
        
        // 网络错误时显示错误信息
        console.log('网络错误，取消订单失败')
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      }
    })
  },



  // 查看权益详情
  onViewBenefits() {
    const benefits = this.data.membershipInfo.benefits.join('\n• ')
    wx.showModal({
      title: '会员权益',
      content: `• ${benefits}`,
      showCancel: false
    })
  },

  // 购买会员套餐
  onPurchaseMembership(e) {
    const planId = e.currentTarget.dataset.planId
    const plan = this.data.vipPlans.find(p => p.id === planId)
    
    if (!plan) {
      wx.showToast({
        title: '套餐信息错误',
        icon: 'none'
      })
      return
    }

        this.purchasePlan(plan)
  },

  // 购买套餐
  purchasePlan(plan) {
    wx.showModal({
      title: '确认购买',
      content: `确定要购买${plan.vipname}吗？\n价格：¥${plan.price}\n有效期：${plan.viptime}天`,
      success: (res) => {
        if (res.confirm) {
          this.processPurchase(plan)
        }
      }
    })
  },

  // 处理购买
  processPurchase(plan) {
          wx.showLoading({
      title: '下单中...'
    })

    // 获取用户ID
    const globalUserInfo = getApp().getUserInfo()
    const userId = globalUserInfo ? globalUserInfo.id : null
    
    if (!userId) {
      wx.hideLoading()
      wx.showToast({
        title: '用户信息错误',
        icon: 'none'
      })
      return
    }

    // 调用下单API
    wx.request({
      url: `http://localhost:8081/viporder/vipOrderAdd?userid=${userId}&viptcid=${plan.id}`,
      method: 'GET',
      success: (res) => {
        wx.hideLoading()
        
        console.log('下单API响应:', res.data)
        console.log('响应状态码:', res.statusCode)
        console.log('响应头:', res.header)
        console.log('数据类型:', typeof res.data)
        console.log('是否为数组:', Array.isArray(res.data))
        
        // 检查多种成功条件
        const isSuccess = (res.data && res.data.code === 200) || 
                         (res.data && res.data.code === 0) ||
                         (res.data && res.data.success === true) ||
                         (res.statusCode === 200 && res.data) ||
                         (Array.isArray(res.data) && res.data.length > 0)
        
        if (isSuccess) {
          wx.showToast({
            title: '下单成功！',
            icon: 'success'
          })
          
          // 刷新订单列表
          this.loadVipOrders()
          
          // 显示支付提示
          setTimeout(() => {
            wx.showModal({
              title: '支付提示',
              content: '订单已创建，请在订单列表中完成支付',
              showCancel: false,
              confirmText: '去支付',
              success: (modalRes) => {
                if (modalRes.confirm) {
                  // 滚动到订单列表
                  wx.pageScrollTo({
                    selector: '.vip-orders',
                    duration: 300
                  })
                }
              }
            })
          }, 1500)
        } else {
          console.log('下单失败，响应数据:', res.data)
          wx.showToast({
            title: res.data?.message || res.data?.msg || '下单失败',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        wx.hideLoading()
        console.error('下单失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      }
    })
  },

  // 去登录
  goToLogin() {
    wx.navigateTo({
      url: '/pages/login/login'
    })
  },

  // 下拉刷新
  onPullDownRefresh() {
    this.loadMembershipInfo()
    this.loadVipPlans()
    this.loadVipOrders()
    wx.stopPullDownRefresh()
  }
})
